#!/usr/bin/pythonv
# -*- coding: utf-8 -*-

# QVS-GTK - Quanto Vinco Se..... 2.0
# Programma per calcolare la vincita al lotto
#
# QVS-GTK è Copyright (C) 2009-2010 di Borgia Michele (Urturino) urturino+qvs@gmail.com
#
# QVS-GTK è un software libero; è possibile ridistribuirlo
# e/o modificarlo secondo i termini della GNU General Public License
# come pubblicato dalla Free Software Foundation; sia utilizzando
# la versione 3 della Licenza, oppure (a propria scelta) una qualunque versione successiva.
#
# QVS-GTK è distribuito con l'auspicio di essere utile,
# ma SENZA ALCUNA GARANZIA; senza nemmeno l'implicita garanzia di COMMERCIABILITÀ
# oppure di APPROPRIATEZZA PER UN PARTICOLARE SCOPO.
# Si veda la GNU General Public License per avere ulteriori dettagli.
#
# Si dovrebbe aver ricevuto una copia della GNU General Public License
# insieme a QVS-GTK; in caso contrario, si scriva a Free Software
# Foundation, Inc., 59 Temple Place,Suite 330, Boston, MA  02111-1307  USA

from qvslib2 import *
from qvstat2 import *
import gtk
import gtk.glade
import pygtk
import sys
import os
pygtk.require("2.0")

ruota=[1.00] #imposto la ruota fissa come predefinita
importi={"e":0,"a":0,"t":0,"q":0,"c":0,"e1":0,"e2":0,"e3":0,"e4":0,"e5":0,"10elotto":0}
tipo_giocata={"lotto":"false","determinato":"false"}
finestra_licenza=[0]
sys.path.append(os.path.abspath(os.path.dirname(sys.argv[0])))


def azzera_vincite():
    entrywin11.set_text("0.00")
    entrywintot1.set_text("0.00")
    entrywin12.set_text("0.00")
    entrywin22.set_text("0.00")
    entrywintot2.set_text("0.00")
    entrywin13.set_text("0.00")
    entrywin23.set_text("0.00")
    entrywin33.set_text("0.00")
    entrywintot3.set_text("0.00")
    entrywin14.set_text("0.00")
    entrywin24.set_text("0.00")
    entrywin34.set_text("0.00")
    entrywin44.set_text("0.00")
    entrywintot4.set_text("0.00")
    entrywin15.set_text("0.00")
    entrywin25.set_text("0.00")
    entrywin35.set_text("0.00")
    entrywin45.set_text("0.00")
    entrywin55.set_text("0.00")
    entrywintot5.set_text("0.00")
    entrydet1.set_text("0.00")
    entrydet2.set_text("0.00")
    entrydet3.set_text("0.00")
    entrydet4.set_text("0.00")
    entrydet5.set_text("0.00")
    win_10_0.set_text("0.00")
    win_10_5.set_text("0.00")
    win_10_6.set_text("0.00")
    win_10_7.set_text("0.00")
    win_10_8.set_text("0.00")
    win_10_9.set_text("0.00")
    win_10_10.set_text("0.00")

def calcola(giocati):
    azzera_vincite()
    totale=0
    if tipo_giocata["lotto"]=="true":
        combinazioni={
        'estratto': [1,2,3,4,5,6,7,8,9,10],
        'ambo': [0,1,3,6,10,15,21,28,36,46],
        'terno': [0,0,1,4,10,20,35,56,84,120],
        'quaterna': [0,0,0,1,5,15,35,70,126,210],
        'cinquina': [0,0,0,0,1,6,21,56,126,252]
        }
        #prometto che nella prossima versione unirò i seguenti 4 cicli for
        #estratto
        for i in range(giocati):
            if i>4:
                break
            eval("entrywin1"+str(i+1)).set_text(str((11.232/combinazioni["estratto"][giocati-1]*combinazioni["estratto"][i]*importi["e"])/ruota[0]))
        #ambo
        for i in range(giocati-1):
            if i>3:
                break
            eval("entrywin2"+str(i+2)).set_text(str((250.00/combinazioni["ambo"][giocati-1]*combinazioni["ambo"][i+1]*importi["a"])/ruota[0]))
        #terno
        for i in range(giocati-2):
            if i>2:
                break
            eval("entrywin3"+str(i+3)).set_text(str((4500.00/combinazioni["terno"][giocati-1]*combinazioni["terno"][i+2]*importi["t"])/ruota[0]))
        #quaterna
        for i in range(giocati-3):
            if i>1:
                break
            eval("entrywin4"+str(i+4)).set_text(str((120000.00/combinazioni["quaterna"][giocati-1]*combinazioni["quaterna"][i+3]*importi["q"])/ruota[0]))
        #cinquina
        if giocati>4:
            entrywin55.set_text(str((6000000.00/combinazioni["cinquina"][giocati-1]*1.00*importi["c"])/ruota[0]))
        #e adesso i totali
        entrywintot1.set_text(entrywin11.get_text())
        entrywintot2.set_text(str(float(entrywin12.get_text())+float(entrywin22.get_text())))
        entrywintot3.set_text(str(float(entrywin13.get_text())+float(entrywin23.get_text())+float(entrywin33.get_text())))
        entrywintot4.set_text(str(float(entrywin14.get_text())+float(entrywin24.get_text())+float(entrywin34.get_text())+float(entrywin44.get_text())))
        entrywintot5.set_text(str(float(entrywin15.get_text())+float(entrywin25.get_text())+float(entrywin35.get_text())+float(entrywin45.get_text())+float(entrywin55.get_text())))
        #l'importo massimo che è possibile vincere è il totale più altro tra quelli calcolati
        totale=arrotonda(tassalo(float(eval("entrywintot"+str(giocati if giocati<6 else 5)).get_text())))
        #se vuoi i risultati tassati, arrotondati e formattati, questo è un buon momento per crearli.
        for i in range(giocati if giocati<6 else 5):
            for j in range(i+1):
                eval("entrywin"+str(j+1)+str(i+1)).set_text(formattazione(arrotonda(tassalo(float(eval("entrywin"+str(j+1)+str(i+1)).get_text())))))
            eval("entrywintot"+str(i+1)).set_text(formattazione(arrotonda(tassalo(float(eval("entrywintot"+str(i+1)).get_text())))))
    if tipo_giocata["determinato"]=="true":
        molt=[55.00,27.50,18.33,13.75,11.00,9.17,7.86,6.88,6.11,5.50]
        for i in range(5):
            eval("entrydet"+str(i+1)).set_text(str((importi["e"+str(i+1)]*molt[giocati-1])/ruota[0]))
        #Alla vincita massima possibile vanno aggiunti i "n" importi più alti, n=giocati
        maggiori=[]
        for i in range(5):
            maggiori.append(float(eval("entrydet"+str(i+1)).get_text()))
        maggiori.sort()
        maggiori.reverse()
        for i in range(giocati if giocati<6 else 5):
            totale=totale+arrotonda(tassalo(maggiori[0]))
            del maggiori[0]
        #Non mi resta che tassare, arrotondare e formattare i risultati del determinato.....e sperare di non aver sbagliato nulla.
        for i in range(5):
            eval("entrydet"+str(i+1)).set_text(formattazione(arrotonda(tassalo(float(eval("entrydet"+str(i+1)).get_text())))))
    if totale>5640000.00:
        azzera_vincite()
        lblcomunicazioni.set_label("<span background='red'>Puntata non giocabile: La puntata supera la vincita massima consentita</span>")
    win_10_0.set_text(formattazione(importi["10elotto"]*2.00))
    win_10_5.set_text(formattazione(importi["10elotto"]*5.00))
    win_10_6.set_text(formattazione(importi["10elotto"]*15.00))
    win_10_7.set_text(formattazione(importi["10elotto"]*100.00))
    win_10_8.set_text(formattazione(importi["10elotto"]*1000.00))
    win_10_9.set_text(formattazione(importi["10elotto"]*30000.00))
    win_10_10.set_text(formattazione(importi["10elotto"]*500000.00))


def on_window1_destroy(widget, data=None):
    gtk.main_quit()

def on_button_esci_clicked(widget, data=None):
    gtk.main_quit()

def on_radiobutton_fissa_pressed(widget, data=None):
    #lblcomunicazioni.set_label("hai attivato 'ruota fissa'")
    del ruota[0]
    ruota.append(1.00)
    cambiato(0)

def on_radiobutton_tutte_pressed(widget, data=None):
    #lblcomunicazioni.set_label("hai attivato 'ruote tutte'")
    del ruota[0]
    ruota.append(10.00)
    cambiato(0)

def on_btnprec_clicked(widget, data=None):
    if tr.index<>0:
        tr.index=tr.index-1
        tr.combo_estrazione.set_active(tr.index)

def on_btnsuc_clicked(widget, data=None):
    if tr.index<>len(tr.estrazioni)-1:
        tr.index=tr.index+1
        tr.combo_estrazione.set_active(tr.index)

def on_combo_estrazione_changed(widget, data=None):
    #la prima volta che viene chiamata tr non è stato ancora dichiarato
    #quindi uso la try per non far uscire l'errore
    try:
        tr.index=tr.combo_estrazione.get_active()
        tr.find_est()
    except:
        pass

def trova_importo_corrispondente(numero,totale):
    if numero==1:
        totale=totale+importi["e"]
    if numero==2:
        totale=totale+importi["a"]
    if numero==3:
        totale=totale+importi["t"]
    if numero==4:
        totale=totale+importi["q"]
    if numero==5:
        totale=totale+importi["c"]
    return totale

def calcola_totale_importi_giocati(giocati):
    totale=0.00
    lista_giocati=range(giocati+1)
    del lista_giocati[0]
    for i in range(giocati):
        totale=trova_importo_corrispondente(i+1,totale)
    return totale

def cambiato(widget, data=None):
    giocati = combogiocati.get_active()
    giocati=giocati+1 #perché parte da 0
    #ora so quanti numeri sono stati giocati
    importi["e"]=spinestratto.get_value()
    importi["a"]=spinambo.get_value()
    importi["t"]=spinterno.get_value()
    importi["q"]=spinquaterna.get_value()
    importi["c"]=spincinquina.get_value()
    importi["e1"]=spindeterminato1.get_value()
    importi["e2"]=spindeterminato2.get_value()
    importi["e3"]=spindeterminato3.get_value()
    importi["e4"]=spindeterminato4.get_value()
    importi["e5"]=spindeterminato5.get_value()
    importi["10elotto"]=spin_10elotto.get_value()
    totale_lotto=calcola_totale_importi_giocati(giocati)
    #è importante capire cosa è stato giocato (lotto e/o determinato)
    #se totale=0 è true allora non ho giocato il lotto
    tipo_giocata["lotto"]="true" if totale_lotto<>0 else "false"
    #calcola_totale_importi_giocati associa solo i totali del lotto classico, aggiungo i determianti
    totale_determinato=importi["e1"]+importi["e2"]+importi["e3"]+importi["e4"]+importi["e5"]
    tipo_giocata["determinato"]="true" if totale_determinato<>0 else "false"
    totale=totale_lotto+totale_determinato
    entrytotale.set_text(formattazione(str(totale)))
    if totale>200.00:
        lblcomunicazioni.set_label("<span background='red'>Puntata non giocabile: L'importo L'importo massimo giocabile è 200.00 €</span>")
        azzera_vincite()
    else:
        if totale<1.00 and totale<>0.00:
            lblcomunicazioni.set_label("<span background='red'>Puntata non giocabile: L'importo minimo giocabile è 1.00 €</span>")
            azzera_vincite()
        else:
            if controllo_multiplo(importi.values(),0.05)=="true":
                if controllo_multiplo(totale,0.50)=="true":
                    if controllo_multiplo(importi["10elotto"],0.50)=="true":
                        lblcomunicazioni.set_label("")
                        calcola(giocati)
                    else:
                        lblcomunicazioni.set_label("<span background='red'>Attenzione: Importo 10eLotto errato</span>")
                        azzera_vincite()
                else:
                    lblcomunicazioni.set_label("<span background='red'>Puntata non giocabile: Importo totale non arrotondato a multipli di 0.50</span>")
                    azzera_vincite()
            else:
                lblcomunicazioni.set_label("<span background='red'>Puntata non giocabile: Ci sono importi non multipli di 0.05</span>")
                azzera_vincite()


def azzera_tutto(widget, data=None):
    azzera_vincite()
    combogiocati.set_active(0) #imposto come default il valore 1
    radiobutton_fissa.set_active(1) #fuoco a "ruota fissa"
    spinestratto.set_value(0.0)
    spinambo.set_value(0.0)
    spinterno.set_value(0.0)
    spinquaterna.set_value(0.0)
    spincinquina.set_value(0.0)
    spin_10elotto.set_value(0.0)
    spindeterminato1.set_value(0.0)
    spindeterminato2.set_value(0.0)
    spindeterminato3.set_value(0.0)
    spindeterminato4.set_value(0.0)
    spindeterminato5.set_value(0.0)
    notebook1.set_current_page(0)
    spinestratto.grab_focus()


def on_button_informazioni_clicked(widget, data=None): #Ma usare una classe, no?
    def on_button_esci_clicked(widget, data=None):
        window_info.destroy()

    def on_button_licenza_clicked(widget, data=None):
        gladeFile2= gtk.glade.XML(os.path.abspath(os.path.dirname(sys.argv[0]))+"/"+"qvsinfo.glade")
        segnali_info = {
        'on_button_esci_clicked': on_button_esci_clicked,
        'on_button_licenza_clicked': on_button_licenza_clicked,
        'on_button_chiudi_clicked':on_button_chiudi_clicked
        }
        gladeFile2.signal_autoconnect(segnali_info)
        window_licenza = gladeFile2.get_widget("window_licenza")
        window_licenza.show()
        del finestra_licenza[0]
        finestra_licenza.append(window_licenza)


    def on_button_chiudi_clicked(widget, data=None):
        window_licenza=finestra_licenza[0]
        window_licenza.destroy()

    gladeFile2= gtk.glade.XML(os.path.abspath(os.path.dirname(sys.argv[0]))+"/"+"qvsinfo.glade")
    segnali_info = {
        'on_button_esci_clicked': on_button_esci_clicked,
        'on_button_licenza_clicked': on_button_licenza_clicked,
        'on_button_chiudi_clicked':on_button_chiudi_clicked
    }
    gladeFile2.signal_autoconnect(segnali_info)
    window_info = gladeFile2.get_widget("window_info")
    window_info.show()

def cambio(a,b,c):
    print c
    if c==1:
        print time.clock()
        download_estrazioni.join()
        print time.clock()
    if c==2:
        print time.clock()
        download_ritardatari.join()
        print time.clock()

#==============================
#==============================
#==============================


segnali = {
  'on_window1_destroy': on_window1_destroy,
  'on_button_esci_clicked': on_button_esci_clicked,
  'on_radiobutton_fissa_pressed': on_radiobutton_fissa_pressed,
  'on_radiobutton_tutte_pressed': on_radiobutton_tutte_pressed,
  'qualcosa_e_cambiato': cambiato,
  'on_button_ricomincia_clicked': azzera_tutto,
  'on_button_informazioni_clicked': on_button_informazioni_clicked,
  'on_btnprec_clicked':on_btnprec_clicked,
  'on_btnsuc_clicked':on_btnsuc_clicked,
  'on_combo_estrazione_changed':on_combo_estrazione_changed,
  'on_notebook2_switch_page':cambio
}

# CARICHIAMO IL FILE GLADE E COLLEGHIAMO I SEGNALI
gladeFile = gtk.glade.XML(os.path.abspath(os.path.dirname(sys.argv[0]))+"/"+"qvs-gtk.glade")
window1 = gladeFile.get_widget("window1")
gladeFile.signal_autoconnect(segnali)

# COLLEGHIAMO I VARI OGGETTI CON DELLE VARIABILI

lblcomunicazioni = gladeFile.get_widget('label_comunicazioni')
combogiocati=gladeFile.get_widget('combobox_giocati')
entrytotale=gladeFile.get_widget('entry_totale')

spinestratto=gladeFile.get_widget('spin_estratto')
spinambo=gladeFile.get_widget('spin_ambo')
spinterno=gladeFile.get_widget('spin_terno')
spinquaterna=gladeFile.get_widget('spin_quaterna')
spincinquina=gladeFile.get_widget('spin_cinquina')

spindeterminato1=gladeFile.get_widget('spin_determinato_1')
spindeterminato2=gladeFile.get_widget('spin_determinato_2')
spindeterminato3=gladeFile.get_widget('spin_determinato_3')
spindeterminato4=gladeFile.get_widget('spin_determinato_4')
spindeterminato5=gladeFile.get_widget('spin_determinato_5')

radiobutton_fissa=gladeFile.get_widget('radiobutton_fissa')
radiobutton_tutte=gladeFile.get_widget('radiobutton_tutte')
entrytotale=gladeFile.get_widget('entry_totale')

entrywin11=gladeFile.get_widget('entry_win_1_1')
entrywintot1=gladeFile.get_widget('entry_win_tot_1')

entrywin12=gladeFile.get_widget('entry_win_1_2')
entrywin22=gladeFile.get_widget('entry_win_2_2')
entrywintot2=gladeFile.get_widget('entry_win_tot_2')

entrywin13=gladeFile.get_widget('entry_win_1_3')
entrywin23=gladeFile.get_widget('entry_win_2_3')
entrywin33=gladeFile.get_widget('entry_win_3_3')
entrywintot3=gladeFile.get_widget('entry_win_tot_3')

entrywin14=gladeFile.get_widget('entry_win_1_4')
entrywin24=gladeFile.get_widget('entry_win_2_4')
entrywin34=gladeFile.get_widget('entry_win_3_4')
entrywin44=gladeFile.get_widget('entry_win_4_4')
entrywintot4=gladeFile.get_widget('entry_win_tot_4')

entrywin15=gladeFile.get_widget('entry_win_1_5')
entrywin25=gladeFile.get_widget('entry_win_2_5')
entrywin35=gladeFile.get_widget('entry_win_3_5')
entrywin45=gladeFile.get_widget('entry_win_4_5')
entrywin55=gladeFile.get_widget('entry_win_5_5')
entrywintot5=gladeFile.get_widget('entry_win_tot_5')

entrydet1=gladeFile.get_widget('entry_det_1')
entrydet2=gladeFile.get_widget('entry_det_2')
entrydet3=gladeFile.get_widget('entry_det_3')
entrydet4=gladeFile.get_widget('entry_det_4')
entrydet5=gladeFile.get_widget('entry_det_5')

spin_10elotto=gladeFile.get_widget('spin_10elotto')
win_10_0=gladeFile.get_widget('win_10_0')
win_10_5=gladeFile.get_widget('win_10_5')
win_10_6=gladeFile.get_widget('win_10_6')
win_10_7=gladeFile.get_widget('win_10_7')
win_10_8=gladeFile.get_widget('win_10_8')
win_10_9=gladeFile.get_widget('win_10_9')
win_10_10=gladeFile.get_widget('win_10_10')

notebook1=gladeFile.get_widget('notebook1')


azzera_tutto(0) #Imposto tutti i campi ai loro valori di default

import threading
class Down_estr(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        tr.scarica_est()
        tr.combo_estrazione.set_active(tr.index)#automaticamente verrà scaricata l'ultima estrazione

class Down_rita(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        rt.scarica_rit()

import time
tr=Estrazioni(gladeFile)
rt=Ritardatari(gladeFile)
print time.clock()
download_estrazioni = Down_estr()
download_estrazioni.start()
download_ritardatari= Down_rita()
download_ritardatari.start()
print time.clock()


#radiobutton_tutte.set_active(1)
#radiobutton_fissa.set_active(1) #valori diversi da 0 settano attivo il radio button


if window1:
    window1.show()
    gtk.main()
